package com.example.ai;

import org.springframework.ai.chat.ChatClient;
import org.springframework.ai.chat.ChatResponse;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.PromptTemplate;
import org.springframework.ai.openai.OpenAiChatClient;
import org.springframework.ai.openai.OpenAiChatOptions;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Spring AI配置类，用于配置AI相关的Bean和服务
 */
@Configuration
public class AIConfig {

    @Value("${spring.ai.openai.chat.model:gpt-3.5-turbo}")
    private String modelName;

    @Value("${spring.ai.openai.chat.temperature:0.7}")
    private Float temperature;

    @Value("${spring.ai.openai.chat.max-tokens:2000}")
    private Integer maxTokens;

    // 用于存储不同配置的ChatClient实例
    private final Map<String, ChatClient> chatClientCache = new ConcurrentHashMap<>();

    /**
     * 默认的OpenAI ChatClient配置
     */
    @Bean
    public OpenAiChatOptions defaultOpenAiChatOptions() {
        return OpenAiChatOptions.builder()
                .withModel(modelName)
                .withTemperature(temperature)
                .withMaxTokens(maxTokens)
                .build();
    }

    /**
     * 提供自定义参数的ChatClient创建方法
     * @param options OpenAI聊天选项
     * @return 配置好的ChatClient实例
     */
    public ChatClient createChatClient(OpenAiChatOptions options) {
        String cacheKey = generateCacheKey(options);
        return chatClientCache.computeIfAbsent(cacheKey, key -> {
            return new OpenAiChatClient(null, options);
        });
    }

    /**
     * 创建指定模型和参数的ChatClient
     * @param model 模型名称
     * @param temperature 温度参数
     * @param maxTokens 最大token数
     * @return 配置好的ChatClient实例
     */
    public ChatClient createChatClient(String model, Float temperature, Integer maxTokens) {
        OpenAiChatOptions options = OpenAiChatOptions.builder()
                .withModel(model)
                .withTemperature(temperature)
                .withMaxTokens(maxTokens)
                .build();
        return createChatClient(options);
    }

    /**
     * 生成缓存键
     */
    private String generateCacheKey(OpenAiChatOptions options) {
        return String.format("%s_%.1f_%d", 
                options.getModel(), 
                options.getTemperature(), 
                options.getMaxTokens());
    }

    /**
     * 创建PromptTemplate实例，用于处理模板化的提示词
     * @param template 模板字符串
     * @return PromptTemplate实例
     */
    public PromptTemplate createPromptTemplate(String template) {
        return new PromptTemplate(template);
    }

    /**
     * 使用模板和参数创建Prompt
     * @param template 模板字符串
     * @param params 模板参数
     * @return Prompt实例
     */
    public Prompt createPrompt(String template, Map<String, Object> params) {
        PromptTemplate promptTemplate = createPromptTemplate(template);
        return promptTemplate.create(params);
    }

    /**
     * 执行带模板的AI调用
     * @param chatClient ChatClient实例
     * @param template 模板字符串
     * @param params 模板参数
     * @return AI响应内容
     */
    public String executeTemplatePrompt(ChatClient chatClient, String template, Map<String, Object> params) {
        Prompt prompt = createPrompt(template, params);
        ChatResponse response = chatClient.call(prompt);
        return response.getResult().getOutput().getContent();
    }
}